package com.project.demo.service;

import com.alipay.api.AlipayApiException;
import com.alipay.api.AlipayClient;
import com.alipay.api.DefaultAlipayClient;
import com.alipay.api.domain.AlipayTradePrecreateModel;
import com.alipay.api.domain.AlipayTradePagePayModel;
import com.alipay.api.request.AlipayTradePrecreateRequest;
import com.alipay.api.request.AlipayTradePagePayRequest;
import com.alipay.api.response.AlipayTradePrecreateResponse;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.client.j2se.MatrixToImageWriter;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.qrcode.QRCodeWriter;
import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.security.MessageDigest;
import java.util.*;

/**
 * 支付服务类
 * 处理微信支付和支付宝支付的二维码生成
 */
@Slf4j
@Service
public class PaymentService {

    // 支付宝配置（从application.yml读取）
    @Value("${payment.alipay.appId:}")
    private String alipayAppId;
    
    @Value("${payment.alipay.privateKey:}")
    private String alipayPrivateKey;
    
    @Value("${payment.alipay.publicKey:}")
    private String alipayPublicKey;
    
    @Value("${payment.alipay.serverUrl:https://openapi.alipay.com/gateway.do}")
    private String alipayServerUrl;
    
    @Value("${payment.alipay.format:JSON}")
    private String alipayFormat;
    
    @Value("${payment.alipay.charset:UTF-8}")
    private String alipayCharset;
    
    @Value("${payment.alipay.signType:RSA2}")
    private String alipaySignType;
    
    @Value("${payment.alipay.notifyUrl:}")
    private String alipayNotifyUrl;
    
    // 是否强制使用模拟二维码（开发测试用）
    @Value("${payment.alipay.useMock:true}")
    private boolean useMockQRCode;
    
    // 微信支付配置（从application.yml读取）
    @Value("${payment.wechat.appId:}")
    private String wechatAppId;
    
    @Value("${payment.wechat.mchId:}")
    private String wechatMchId;
    
    @Value("${payment.wechat.apiKey:}")
    private String wechatApiKey;
    
    @Value("${payment.wechat.certPath:}")
    private String wechatCertPath;
    
    @Value("${payment.wechat.notifyUrl:}")
    private String wechatNotifyUrl;

    // 微信支付V2 API统一下单URL
    private static final String WECHAT_UNIFIED_ORDER_URL = "https://api.mch.weixin.qq.com/pay/unifiedorder";
    
    // RestTemplate用于HTTP请求
    private final RestTemplate restTemplate = new RestTemplate();

    /**
     * 生成支付宝支付二维码
     * @param orderNumber 订单编号
     * @param amount 支付金额（单位：元）
     * @param subject 订单标题
     * @return 二维码图片的Base64编码或二维码内容
     */
    public Map<String, Object> generateAlipayQRCode(String orderNumber, String amount, String subject) {
        Map<String, Object> result = new HashMap<>();
        
        try {
            // 如果配置了强制使用模拟模式，或未配置支付宝参数，则使用模拟二维码
            if (useMockQRCode || !isAlipayConfigured()) {
                // 使用模拟数据（用于测试和开发）
                log.info("使用模拟支付宝二维码 - 订单号：{}，金额：{}", orderNumber, amount);
                
                // 生成模拟二维码内容
                // 注意：模拟二维码无法真实支付，仅用于开发测试
                // 使用支付宝标准二维码URL格式，但指向测试地址
                // 格式：https://qr.alipay.com/bax[订单号]
                String orderShort = orderNumber.length() > 10 ? orderNumber.substring(orderNumber.length() - 10) : orderNumber;
                String mockQRCodeContent = "https://qr.alipay.com/bax" + orderShort;
                
                // 注意：模拟二维码扫码后会提示"二维码已失效"
                // 这是正常的，因为这不是真实支付宝生成的二维码
                // 如果要测试真实支付，需要：
                // 1. 配置完整的支付宝参数（appId、私钥、公钥）
                // 2. 设置 useMock: false
                // 3. 确保网络可以访问支付宝服务器
                
                String qrCodeImageBase64 = generateQRCodeImage(mockQRCodeContent);
                
                result.put("success", true);
                result.put("qrcode_content", mockQRCodeContent);
                result.put("qrcode_image_base64", qrCodeImageBase64);
                result.put("qrcode_url", "data:image/png;base64," + qrCodeImageBase64);
                result.put("mock", true);
                log.info("模拟支付宝二维码生成成功，订单号：{}，内容：{}", orderNumber, mockQRCodeContent);
            } else if (isAlipayConfigured()) {
                // 如果配置了支付宝参数且未强制使用模拟模式，则调用真实接口
                // 创建支付宝客户端（设置超时时间：连接超时60秒，读取超时120秒）
                // 如果仍然超时，可能是网络无法访问支付宝服务器，建议检查网络或使用代理
                AlipayClient alipayClient = new DefaultAlipayClient(
                    alipayServerUrl,
                    alipayAppId,
                    alipayPrivateKey,
                    alipayFormat,
                    alipayCharset,
                    alipayPublicKey,
                    alipaySignType,
                    "60000",  // 连接超时时间（毫秒）：60秒
                    "120000"   // 读取超时时间（毫秒）：120秒
                );
                
                // 创建请求对象
                AlipayTradePrecreateRequest request = new AlipayTradePrecreateRequest();
                AlipayTradePrecreateModel model = new AlipayTradePrecreateModel();
                
                // 设置订单信息
                // 订单号必须唯一，长度限制：64个字符以内
                // 订单号只能包含：数字、字母、下划线、短横线
                if (orderNumber == null || orderNumber.trim().isEmpty()) {
                    log.error("订单号不能为空");
                    result.put("success", false);
                    result.put("message", "订单号不能为空");
                    return result;
                }
                
                // 验证订单号格式（支付宝要求：只能包含字母、数字、下划线）
                String sanitizedOrderNumber = orderNumber.replaceAll("[^a-zA-Z0-9_]", "_");
                if (!sanitizedOrderNumber.equals(orderNumber)) {
                    log.warn("订单号包含特殊字符，已清理：{} -> {}", orderNumber, sanitizedOrderNumber);
                }
                
                // 订单号长度限制
                if (sanitizedOrderNumber.length() > 64) {
                    sanitizedOrderNumber = sanitizedOrderNumber.substring(0, 64);
                    log.warn("订单号过长，已截断：{}", sanitizedOrderNumber);
                }
                
                model.setOutTradeNo(sanitizedOrderNumber);
                
                // 验证金额格式（必须是数字，且最多两位小数）
                try {
                    double amountValue = Double.parseDouble(amount);
                    if (amountValue <= 0) {
                        throw new IllegalArgumentException("支付金额必须大于0");
                    }
                    // 格式化为最多两位小数
                    model.setTotalAmount(String.format("%.2f", amountValue));
                    log.info("设置支付金额：{}元", model.getTotalAmount());
                } catch (NumberFormatException e) {
                    log.error("支付金额格式错误：{}", amount);
                    result.put("success", false);
                    result.put("message", "支付金额格式错误：" + amount);
                    return result;
                }
                
                model.setSubject(subject != null ? subject : "会议报名费用");
                model.setTimeoutExpress("30m"); // 订单超时时间（30分钟）
                
                // 记录订单信息
                log.info("创建支付宝订单 - 订单号：{}，金额：{}元，标题：{}", 
                    orderNumber, model.getTotalAmount(), model.getSubject());
                
                request.setBizModel(model);
                
                // 设置回调地址
                // 注意：即使回调地址不可访问，也不会影响订单创建（回调失败不影响支付）
                // 沙箱环境可以使用任意URL，生产环境建议使用真实可访问的HTTPS地址
                if (alipayNotifyUrl != null && !alipayNotifyUrl.isEmpty()) {
                    request.setNotifyUrl(alipayNotifyUrl);
                    log.info("设置支付回调地址：{}", alipayNotifyUrl);
                } else {
                    // 如果未配置回调地址，在沙箱环境下设置一个默认地址（用于测试）
                    // 生产环境建议配置真实的回调地址
                    if (alipayServerUrl.contains("alipaydev.com")) {
                        // 沙箱环境：使用一个测试地址（即使不存在也不会影响订单创建）
                        String defaultNotifyUrl = "http://localhost:5000/api/payment/alipay/notify";
                        request.setNotifyUrl(defaultNotifyUrl);
                        log.info("使用默认回调地址（沙箱环境）：{}", defaultNotifyUrl);
                    } else {
                        // 生产环境：如果没有配置回调地址，不设置（可选参数）
                        log.warn("生产环境未配置回调地址，建议配置notifyUrl以接收支付通知");
                    }
                }
                
                log.info("调用支付宝预创建订单接口 - 订单号：{}，金额：{}元，服务器：{}", orderNumber, amount, alipayServerUrl);
                
                // 调用API（增加超时保护和详细日志）
                AlipayTradePrecreateResponse response;
                long startTime = System.currentTimeMillis();
                try {
                    log.info("开始调用支付宝API，时间：{}", startTime);
                    response = alipayClient.execute(request);
                    long endTime = System.currentTimeMillis();
                    log.info("支付宝API调用完成，耗时：{}毫秒", (endTime - startTime));
                } catch (Exception e) {
                    long endTime = System.currentTimeMillis();
                    log.error("支付宝API调用失败，耗时：{}毫秒，错误类型：{}", (endTime - startTime), e.getClass().getSimpleName());
                    
                    // 捕获超时或其他网络异常
                    String errorMessage = e.getMessage();
                    if (errorMessage != null) {
                        log.error("错误详情：{}", errorMessage);
                        
                        if (errorMessage.contains("timeout") || errorMessage.contains("Timeout") 
                            || errorMessage.contains("Read timed out") || errorMessage.contains("Connection timed out")
                            || errorMessage.contains("SocketTimeoutException")) {
                            
                            String timeoutMsg = String.format(
                                "支付宝接口请求超时（耗时%d秒），可能原因：\n" +
                                "1. 网络无法访问支付宝服务器（%s）\n" +
                                "2. 防火墙或代理限制\n" +
                                "3. 沙箱环境不稳定\n" +
                                "建议：检查网络连接或暂时使用模拟二维码进行测试",
                                (endTime - startTime) / 1000, alipayServerUrl
                            );
                            log.error(timeoutMsg);
                            throw new RuntimeException(timeoutMsg, e);
                        }
                    }
                    throw e;
                }
                
                if (response != null && response.isSuccess() && response.getQrCode() != null) {
                    // 获取支付宝返回的二维码内容（通常是URL格式，如：https://qr.alipay.com/baxxxxxx）
                    String qrCodeContent = response.getQrCode();
                    
                    // 详细日志，记录支付宝返回的完整信息
                    log.info("支付宝返回的二维码内容：{}", qrCodeContent);
                    log.info("支付宝API响应详情 - Code: {}, Msg: {}, SubCode: {}, SubMsg: {}", 
                        response.getCode(), response.getMsg(), response.getSubCode(), response.getSubMsg());
                    
                    // 验证二维码内容格式
                    if (qrCodeContent == null || qrCodeContent.trim().isEmpty()) {
                        log.error("支付宝返回的二维码内容为空");
                        result.put("success", false);
                        result.put("message", "支付宝返回的二维码内容为空");
                        return result;
                    }
                    
                    // 检查二维码内容是否包含必要的支付宝域名
                    if (!qrCodeContent.contains("qr.alipay.com") && !qrCodeContent.contains("alipay.com")) {
                        log.warn("支付宝返回的二维码内容格式可能不正确：{}", qrCodeContent);
                        // 但仍然尝试生成二维码
                    }
                    
                    // 生成二维码图片（使用支付宝返回的原始内容）
                    String qrCodeImageBase64 = generateQRCodeImage(qrCodeContent);
                    
                    result.put("success", true);
                    result.put("qrcode_content", qrCodeContent);
                    result.put("qrcode_image_base64", qrCodeImageBase64);
                    result.put("qrcode_url", "data:image/png;base64," + qrCodeImageBase64);
                    result.put("mock", false); // 标记为真实支付二维码
                    
                    // 判断是否为沙箱环境
                    boolean isSandbox = alipayServerUrl.contains("sandbox") || alipayServerUrl.contains("alipaydev");
                    if (isSandbox) {
                        result.put("sandbox_warning", true);
                        result.put("sandbox_message", "当前使用沙箱环境，扫码支付时必须使用支付宝沙箱测试账号，普通账号扫码会提示失效");
                        log.info("沙箱环境二维码生成成功，订单号：{}，二维码：{}，注意：必须使用沙箱账号扫码", 
                            orderNumber, qrCodeContent);
                    } else {
                        log.info("生产环境二维码生成成功，订单号：{}，二维码内容长度：{}", 
                            orderNumber, qrCodeContent.length());
                    }
                } else {
                    // 详细记录支付宝返回的错误信息
                    String errorMsg = "未知错误";
                    String errorCode = null;
                    String subCode = null;
                    
                    if (response != null) {
                        errorCode = response.getCode();
                        errorMsg = response.getMsg();
                        subCode = response.getSubCode();
                        String subMsg = response.getSubMsg();
                        
                        log.error("支付宝接口返回失败 - 订单号：{}，Code: {}，Msg: {}，SubCode: {}，SubMsg: {}", 
                            orderNumber, errorCode, errorMsg, subCode, subMsg);
                        
                        if (subMsg != null && !subMsg.isEmpty()) {
                            errorMsg = subMsg;
                        } else if (errorMsg == null || errorMsg.isEmpty()) {
                            errorMsg = "支付宝接口调用失败";
                        }
                    } else {
                        log.error("支付宝接口返回为null - 订单号：{}", orderNumber);
                        errorMsg = "支付宝接口返回为空";
                    }
                    
                    result.put("success", false);
                    result.put("message", "支付宝二维码生成失败：" + errorMsg);
                    result.put("error_code", errorCode);
                    result.put("sub_code", subCode);
                }
            }
        } catch (AlipayApiException e) {
            log.error("支付宝API调用失败", e);
            String errorMsg = "支付宝支付失败";
            if (e.getMessage() != null) {
                String msg = e.getMessage();
                if (msg.contains("timeout") || msg.contains("Timeout") || msg.contains("Read timed out")) {
                    errorMsg = "支付宝接口请求超时。可能原因：\n" +
                              "1. 网络无法访问支付宝服务器\n" +
                              "2. 防火墙或代理限制\n" +
                              "3. 沙箱环境不稳定\n" +
                              "建议检查网络连接或联系管理员";
                } else {
                    errorMsg = "支付宝支付失败：" + msg;
                }
            }
            result.put("success", false);
            result.put("message", errorMsg);
        } catch (RuntimeException e) {
            // 捕获我们抛出的超时异常
            log.error("支付宝二维码生成失败（运行时异常）", e);
            String errorMsg = e.getMessage();
            if (errorMsg == null || errorMsg.isEmpty()) {
                errorMsg = "生成二维码失败";
            }
            result.put("success", false);
            result.put("message", errorMsg);
        } catch (Exception e) {
            log.error("生成支付宝二维码失败", e);
            String errorMsg = "生成二维码失败";
            if (e.getMessage() != null) {
                String msg = e.getMessage();
                if (msg.contains("timeout") || msg.contains("Timeout") || msg.contains("Read timed out")) {
                    errorMsg = "网络请求超时。可能原因：\n" +
                              "1. 网络无法访问支付宝服务器\n" +
                              "2. 防火墙或代理限制\n" +
                              "建议检查网络连接";
                } else {
                    errorMsg = "生成二维码失败：" + msg;
                }
            }
            result.put("success", false);
            result.put("message", errorMsg);
        }
        
        return result;
    }

    /**
     * 生成支付宝网页支付链接
     * @param orderNumber 订单编号
     * @param amount 支付金额（单位：元）
     * @param subject 订单标题
     * @param returnUrl 支付成功后的跳转地址（前端页面地址）
     * @return 支付链接
     */
    public Map<String, Object> generateAlipayPagePay(String orderNumber, String amount, String subject, String returnUrl) {
        Map<String, Object> result = new HashMap<>();
        
        try {
            // 如果配置了强制使用模拟模式，或未配置支付宝参数，则返回错误
            if (useMockQRCode || !isAlipayConfigured()) {
                log.warn("支付宝网页支付需要真实配置，当前使用模拟模式或未配置参数");
                result.put("success", false);
                result.put("message", "支付宝网页支付需要配置完整的支付宝参数，请检查application.yml配置");
                return result;
            }
            
            // 创建支付宝客户端
            AlipayClient alipayClient = new DefaultAlipayClient(
                alipayServerUrl,
                alipayAppId,
                alipayPrivateKey,
                alipayFormat,
                alipayCharset,
                alipayPublicKey,
                alipaySignType,
                "60000",  // 连接超时时间（毫秒）：60秒
                "120000"   // 读取超时时间（毫秒）：120秒
            );
            
            // 创建网页支付请求对象
            AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
            AlipayTradePagePayModel model = new AlipayTradePagePayModel();
            
            // 设置订单信息
            String sanitizedOrderNumber = orderNumber.replaceAll("[^a-zA-Z0-9_]", "_");
            if (sanitizedOrderNumber.length() > 64) {
                sanitizedOrderNumber = sanitizedOrderNumber.substring(0, 64);
            }
            model.setOutTradeNo(sanitizedOrderNumber);
            
            // 验证并设置金额
            try {
                double amountValue = Double.parseDouble(amount);
                if (amountValue <= 0) {
                    throw new IllegalArgumentException("支付金额必须大于0");
                }
                model.setTotalAmount(String.format("%.2f", amountValue));
            } catch (NumberFormatException e) {
                log.error("支付金额格式错误：{}", amount);
                result.put("success", false);
                result.put("message", "支付金额格式错误：" + amount);
                return result;
            }
            
            model.setSubject(subject != null ? subject : "会议报名费用");
            model.setProductCode("FAST_INSTANT_TRADE_PAY"); // 固定值，表示即时到账
            
            request.setBizModel(model);
            
            // 设置回调地址
            if (alipayNotifyUrl != null && !alipayNotifyUrl.isEmpty()) {
                request.setNotifyUrl(alipayNotifyUrl);
                log.info("支付宝异步回调地址（notify）：{}", alipayNotifyUrl);
            } else if (alipayServerUrl.contains("alipaydev.com")) {
                String defaultNotifyUrl = "http://localhost:5000/api/payment/alipay/notify";
                request.setNotifyUrl(defaultNotifyUrl);
                log.info("支付宝异步回调地址（notify，默认）：{}", defaultNotifyUrl);
            }
            
            // 设置返回URL（支付成功后跳转的页面）
            if (returnUrl != null && !returnUrl.isEmpty()) {
                request.setReturnUrl(returnUrl);
                log.info("支付宝同步回调地址（return）：{}", returnUrl);
            } else {
                // 如果没有提供returnUrl，使用默认值
                String defaultReturnUrl = "http://localhost:5000/api/payment/alipay/return";
                request.setReturnUrl(defaultReturnUrl);
                log.warn("未提供returnUrl，使用默认值：{}", defaultReturnUrl);
            }
            
            log.info("调用支付宝网页支付接口 - 订单号：{}，金额：{}元，同步回调：{}，异步回调：{}", 
                orderNumber, model.getTotalAmount(), request.getReturnUrl(), request.getNotifyUrl());
            
            // 调用API生成支付表单
            String form = alipayClient.pageExecute(request).getBody();
            
            result.put("success", true);
            result.put("pay_url", form); // 返回HTML表单
            result.put("order_number", sanitizedOrderNumber);
            
            boolean isSandbox = alipayServerUrl.contains("sandbox") || alipayServerUrl.contains("alipaydev");
            if (isSandbox) {
                result.put("sandbox_warning", true);
                log.info("沙箱环境网页支付链接生成成功，订单号：{}", orderNumber);
            }
            
        } catch (AlipayApiException e) {
            log.error("支付宝网页支付API调用失败", e);
            result.put("success", false);
            result.put("message", "支付宝网页支付失败：" + e.getMessage());
        } catch (Exception e) {
            log.error("生成支付宝网页支付链接失败", e);
            result.put("success", false);
            result.put("message", "生成支付链接失败：" + e.getMessage());
        }
        
        return result;
    }

    /**
     * 生成微信支付二维码
     * @param orderNumber 订单编号
     * @param amount 支付金额（单位：分）
     * @param description 商品描述
     * @return 二维码图片的Base64编码或二维码内容
     */
    public Map<String, Object> generateWechatQRCode(String orderNumber, String amount, String description) {
        Map<String, Object> result = new HashMap<>();
        
        try {
            // 微信支付始终使用模拟二维码（用于测试）
            log.info("微信支付使用模拟二维码，订单号：{}", orderNumber);
            String mockQRCodeContent = String.format("weixin://wxpay/bizpayurl?pr=%s", orderNumber);
            String qrCodeImageBase64 = generateQRCodeImage(mockQRCodeContent);
            
            result.put("success", true);
            result.put("qrcode_content", mockQRCodeContent);
            result.put("qrcode_image_base64", qrCodeImageBase64);
            result.put("qrcode_url", "data:image/png;base64," + qrCodeImageBase64);
            result.put("mock", true);
        } catch (Exception e) {
            log.error("生成微信支付二维码失败", e);
            result.put("success", false);
            result.put("message", "生成二维码失败：" + e.getMessage());
        }
        
        return result;
    }

    /**
     * 调用微信支付统一下单接口
     * @param orderNumber 订单编号
     * @param amount 支付金额（单位：分）
     * @param description 商品描述
     * @return 响应结果Map
     */
    private Map<String, String> callWechatUnifiedOrder(String orderNumber, String amount, String description) throws Exception {
        // 构建请求参数
        Map<String, String> params = new TreeMap<>(); // TreeMap自动排序，便于签名
        params.put("appid", wechatAppId);
        params.put("mch_id", wechatMchId);
        params.put("nonce_str", generateNonceStr()); // 随机字符串
        params.put("body", description != null ? description : "会议报名费用");
        params.put("out_trade_no", orderNumber);
        params.put("total_fee", amount); // 金额，单位：分
        params.put("spbill_create_ip", "127.0.0.1"); // 终端IP
        params.put("notify_url", wechatNotifyUrl != null && !wechatNotifyUrl.isEmpty() ? wechatNotifyUrl : ""); // 通知地址
        params.put("trade_type", "NATIVE"); // 扫码支付
        
        // 生成签名
        String sign = generateWechatSign(params);
        params.put("sign", sign);
        
        // 转换为XML格式
        String xmlData = mapToXml(params);
        log.debug("微信支付统一下单请求XML：{}", xmlData);
        
        // 发送HTTP POST请求
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_XML);
        HttpEntity<String> entity = new HttpEntity<>(xmlData, headers);
        
        ResponseEntity<String> response = restTemplate.postForEntity(WECHAT_UNIFIED_ORDER_URL, entity, String.class);
        
        // 解析XML响应
        Map<String, String> responseMap = xmlToMap(response.getBody());
        log.debug("微信支付统一下单响应：{}", responseMap);
        
        return responseMap;
    }

    /**
     * 生成微信支付签名（MD5）
     */
    private String generateWechatSign(Map<String, String> params) throws Exception {
        // 过滤空值并排序
        StringBuilder sb = new StringBuilder();
        params.entrySet().stream()
            .filter(entry -> entry.getValue() != null && !entry.getValue().isEmpty() && !"sign".equals(entry.getKey()))
            .sorted(Map.Entry.comparingByKey())
            .forEach(entry -> {
                if (sb.length() > 0) {
                    sb.append("&");
                }
                sb.append(entry.getKey()).append("=").append(entry.getValue());
            });
        
        // 拼接API密钥
        sb.append("&key=").append(wechatApiKey);
        
        // MD5加密并转大写
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] bytes = md.digest(sb.toString().getBytes("UTF-8"));
        StringBuilder result = new StringBuilder();
        for (byte b : bytes) {
            result.append(String.format("%02x", b));
        }
        
        return result.toString().toUpperCase();
    }

    /**
     * 生成随机字符串
     */
    private String generateNonceStr() {
        return UUID.randomUUID().toString().replace("-", "").substring(0, 32);
    }

    /**
     * Map转XML
     */
    private String mapToXml(Map<String, String> params) {
        StringBuilder xml = new StringBuilder();
        xml.append("<xml>");
        for (Map.Entry<String, String> entry : params.entrySet()) {
            xml.append("<").append(entry.getKey()).append(">");
            xml.append("<![CDATA[").append(entry.getValue()).append("]]>");
            xml.append("</").append(entry.getKey()).append(">");
        }
        xml.append("</xml>");
        return xml.toString();
    }

    /**
     * XML转Map（简单实现）
     */
    private Map<String, String> xmlToMap(String xml) {
        Map<String, String> map = new HashMap<>();
        if (xml == null || xml.isEmpty()) {
            return map;
        }
        
        // 简单的XML解析（如果项目中有XML解析库，建议使用）
        try {
            // 移除XML声明和CDATA
            xml = xml.replaceAll("<!\\[CDATA\\[|\\]\\]>", "");
            
            // 提取所有标签和值
            java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("<(\\w+)>(.*?)</\\1>");
            java.util.regex.Matcher matcher = pattern.matcher(xml);
            
            while (matcher.find()) {
                String key = matcher.group(1);
                String value = matcher.group(2).trim();
                map.put(key, value);
            }
        } catch (Exception e) {
            log.error("XML解析失败", e);
        }
        
        return map;
    }

    /**
     * 生成二维码图片（Base64编码）
     * @param content 二维码内容
     * @return Base64编码的图片字符串
     */
    private String generateQRCodeImage(String content) {
        try {
            int width = 300;
            int height = 300;
            
            Map<EncodeHintType, Object> hints = new HashMap<>();
            hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
            hints.put(EncodeHintType.CHARACTER_SET, "UTF-8");
            hints.put(EncodeHintType.MARGIN, 1);
            
            QRCodeWriter qrCodeWriter = new QRCodeWriter();
            BitMatrix bitMatrix = qrCodeWriter.encode(content, BarcodeFormat.QR_CODE, width, height, hints);
            
            BufferedImage image = MatrixToImageWriter.toBufferedImage(bitMatrix);
            
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            ImageIO.write(image, "PNG", outputStream);
            byte[] imageBytes = outputStream.toByteArray();
            
            return Base64.getEncoder().encodeToString(imageBytes);
        } catch (Exception e) {
            log.error("生成二维码图片失败", e);
            throw new RuntimeException("生成二维码图片失败", e);
        }
    }

    /**
     * 检查支付宝是否已配置
     */
    private boolean isAlipayConfigured() {
        return alipayAppId != null && !alipayAppId.isEmpty() 
            && alipayPrivateKey != null && !alipayPrivateKey.isEmpty()
            && alipayPublicKey != null && !alipayPublicKey.isEmpty();
    }

    /**
     * 检查微信支付是否已配置
     */
    private boolean isWechatConfigured() {
        return wechatAppId != null && !wechatAppId.isEmpty()
            && wechatMchId != null && !wechatMchId.isEmpty()
            && wechatApiKey != null && !wechatApiKey.isEmpty();
    }
}

